package com.zxq.common.utils;

import com.zxq.common.utils.internal.date.DateBetween;
import com.zxq.common.utils.internal.date.DateUnit;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;

/**
 * 定位：致力于解决 日期功能 -> 业务 最后一公里的繁杂问题<br>
 *
 * 时间的表现形式：long（毫秒/秒），Date对象，LocalDate对象，LocalDateTime对象<br>
 * 时间的四种格式：对象，long（毫秒/秒），字符串，Integer（实际也是字符串）<br>
 * 时间的表现形式的转换：<br>
 * --> long（毫秒/秒）<=  Date对象，LocalDate对象，LocalDateTime对象<br>
 * --> Date对象 <=  long（毫秒/秒），LocalDate对象，LocalDateTime对象<br>
 * --> LocalDate对象 <=  long（毫秒/秒），Date对象，LocalDateTime对象<br>
 * --> LocalDateTime对象 <=  long（毫秒/秒），Date对象，LocalDate对象<br>
 * 时间的格式转换：<br>
 * --> long（毫秒/秒），Date对象，LocalDate对象，LocalDateTime对象 => 指定格式的字符串<br>
 * --> 指定格式的字符串(包括Integer格式的时间) => LocalDateTime对象<br>
 * --> 获取时间戳的一部分 => 秒、分、小时、天、月、年<br>
 * 计算类操作：<br>
 * --> 计算偏移 指定单位时间 后的日期 =>  +/- N年/月/日/小时/分/秒<br>
 * --> 计算两个日期的差值 => 年数/月数/周数/天数/小时数/秒数<br>
 * --> 时区计算 <b>暂不涉及</b><br>
 * 判断类：<br>
 * --> 是否在某个区间内<br>
 * --> 是否AM，PM<br>
 */
@SuppressWarnings("unused")
public class DateUtil {

    public static final String YMDS_HMS = "yyyy-MM-dd HH:mm:ss:SSS";
    public static final String YMD_HMS = "yyyy-MM-dd HH:mm:ss";
    public static final String YMD_HM = "yyyy-MM-dd HH:mm";
    public static final String YMD_H = "yyyy-MM-dd HH";
    public static final String YMD = "yyyy-MM-dd";
    public static final String YM = "yyyy-MM";
    public static final String Y = "yyyy";
    public static final String HMS = "HH:mm:ss";
    public static final String HM = "HH:mm";
    public static final String H = "HH";

    public static final String YMDHMS_CHN = "yyyy年MM月dd日HH时mm分ss秒";
    public static final String YMDHM_CHN = "yyyy年MM月dd日HH时mm分";
    public static final String YMDH_CHN = "yyyy年MM月dd日HH时";
    public static final String YMD_CHN = "yyyy年MM月dd日";
    public static final String YM_CHN = "yyyy年MM月";
    public static final String HMS_CHN = "HH时mm分ss秒";
    public static final String HM_CHN = "HH时mm分";
    public static final String H_CHN = "HH时";

    public static final String yyyyMMddHHmmss = "yyyyMMddHHmmss";
    public static final String yyyyMMddHHmm = "yyyyMMddHHmm";
    public static final String yyyyMMddHH = "yyyyMMddHH";
    public static final String yyyyMMdd = "yyyyMMdd";
    public static final String yyyyMM = "yyyyMM";
    public static final String yyyy = "yyyy";

    public static final String yyyy_MM_ddHH_mm = "yyyy-MM-ddHH:mm";

    private static final ArrayList<String> YMD_FORMAT_CACHE_LIST = new ArrayList<>();
    static {
        YMD_FORMAT_CACHE_LIST.addAll(Arrays.asList(YMD, YMD_CHN, yyyyMMdd, "yyyy/MM/dd"));
    }
    /////////////////////////////////////////////////////////IDate:本质是两个时间的不同表现形式

    /**
     * @return 此时此刻
     */
    public static LocalDateTime now() {
        return LocalDateTime.now();
    }

    /**
     * @return 今天日期
     */
    public static LocalDate today() {
        return LocalDate.now();
    }

    /**
     * @return 昨天日期
     */
    public static LocalDate yesterday() {
        return LocalDate.now().plusDays(-1);
    }

    /**
     * @return 明天日期
     */
    public static LocalDate tomorrow() {
        return LocalDate.now().plusDays(1);
    }

    /**
     * 当前时间
     * @return Date
     */
    public static Date date() {
        return new Date();
    }

    /**
     * 毫秒 转 Date
     *
     * @param millisecond 1970/1/1 00:00:00 以来的 毫秒数
     * @return Date 对象
     */
    public static Date date(long millisecond) {
        return date(millisecond, true);
    }

    /**
     * long 时间戳 转 Date
     *
     * @param timestamp long 1970/1/1 00:00:00 以来的 秒数/毫秒数
     * @param isMillis  是否毫秒
     * @return Date 对象
     */
    public static Date date(long timestamp, boolean isMillis) {
        if (isMillis) {
            return new Date(timestamp);
        } else {
            return new Date(timestamp * 1000);
        }
    }

    /**
     * LocalDate 转 Date
     *
     * @param localDate java.time.LocalDate
     * @return java.util.Date
     */
    public static Date date(LocalDate localDate) {
        ZonedDateTime zdt = localDate.atStartOfDay(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * LocalDateTime 转 Date
     *
     * @param dateTime java.time.LocalDateTime
     * @return java.util.Date
     */
    public static Date date(LocalDateTime dateTime) {
        return Date.from(dateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 当前时间
     * @return LocalDate
     */
    public static LocalDate localDate() {
        return LocalDate.now();
    }

    /**
     * Date 转 LocalDate
     *
     * @param date Date对象
     * @return LocalDate 对象
     */
    public static LocalDate localDate(Date date) {
        return localDateTime(date).toLocalDate();
    }

    /**
     * LocalDateTime -> LocalDate
     * @param dateTime LocalDateTime
     * @return LocalDate
     */
    public static LocalDate localDate(LocalDateTime dateTime) {
        return dateTime.toLocalDate();
    }

    /**
     * 毫秒 转 LocalDate
     *
     * @param millisecond 1970/1/1 00:00:00 以来的 毫秒数
     * @return LocalDate对象
     */
    public static LocalDate localDate(long millisecond) {
        return localDate(millisecond, true);
    }

    /**
     * long 时间戳 转 LocalDate
     *
     * @param timestamp long 1970/1/1 00:00:00 以来的 秒数/毫秒数
     * @param isMillis  是否毫秒
     * @return LocalDate 对象
     */
    public static LocalDate localDate(long timestamp, boolean isMillis) {
        return localDateTime(timestamp, isMillis).toLocalDate();
    }

    /**
     * 当前时间
     *
     * @return LocalDateTime
     */
    public static LocalDateTime localDateTime() {
        return LocalDateTime.now();
    }

    /**
     * Date 转 LocalDate
     *
     * @param date java.util.Date
     * @return java.time.LocalDate
     */
    public static LocalDateTime localDateTime(Date date) {
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    /**
     * LocalDate -> LocalDateTime
     * @param localDate LocalDate
     * @return LocalDateTime
     */
    public static LocalDateTime localDateTime(LocalDate localDate) {
        return localDate.atStartOfDay();
    }

    /**
     * 毫秒 转 LocalDateTime
     *
     * @param millisecond 1970/1/1 00:00:00 以来的 毫秒数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime localDateTime(long millisecond) {
        return localDateTime(millisecond, true);
    }

    /**
     * 秒/毫秒 转 LocalDateTime
     *
     * @param timestamp 1970/1/1 00:00:00 以来的 秒数/毫秒数
     * @param isMillis  是否是毫秒
     * @return LocalDateTime 对象
     */
    public static LocalDateTime localDateTime(long timestamp, boolean isMillis) {
        if (isMillis) {
            return LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
        } else {
            return LocalDateTime.ofInstant(Instant.ofEpochSecond(timestamp), ZoneId.systemDefault());
        }
    }

    /**
     * @return 1970/1/1 00:00:00 以来的秒数
     */
    public static long seconds() {
        return LocalDateTime.now().toEpochSecond(OffsetDateTime.now().getOffset());
    }

    /**
     * @param date Date对象
     * @return 1970/1/1 00:00:00 到 date 的秒数
     */
    public static long seconds(Date date) {
        return localDateTime(date).toEpochSecond(OffsetDateTime.now().getOffset());
    }

    /**
     * @param date LocalDate对象
     * @return 1970/1/1 00:00:00 到 date 的秒数
     */
    public static long seconds(LocalDate date) {
        return date.atStartOfDay().toEpochSecond(OffsetDateTime.now().getOffset());
    }

    /**
     * @param dateTime LocalDateTime对象
     * @return 1970/1/1 00:00:00 到 dateTime 的秒数
     */
    public static long seconds(LocalDateTime dateTime) {
        return dateTime.toEpochSecond(OffsetDateTime.now().getOffset());
    }

    /**
     * @return 1970/1/1 00:00:00 到当前时间的 毫秒数
     */
    public static long millis() {
        return LocalDateTime.now().toInstant(OffsetDateTime.now().getOffset()).toEpochMilli();
    }

    /**
     * @param date Date 对象
     * @return 1970/1/1 00:00:00 到 date 的毫秒数
     */
    public static long millis(Date date) {
        return localDateTime(date).toInstant(OffsetDateTime.now().getOffset()).toEpochMilli();
    }

    /**
     * @param localDate LocalDate 对象
     * @return 1970/1/1 00:00:00 到 dateTime 的毫秒数
     */
    public static long millis(LocalDate localDate) {
        return localDate.atStartOfDay().toInstant(OffsetDateTime.now().getOffset()).toEpochMilli();
    }

    /**
     * @param localDateTime LocalDateTime 对象
     * @return 1970/1/1 00:00:00 到 localDateTime 的毫秒数
     */
    public static long millis(LocalDateTime localDateTime) {
        return localDateTime.toInstant(OffsetDateTime.now().getOffset()).toEpochMilli();
    }

    /**
     * @return 当前时刻对应的 纳秒数
     */
    public static long nanoTime() {
        return System.nanoTime();
    }

    /////////////////////////////////////////////////////////IDateFormat

    /**
     * @return 当前日期的 "yyyy-MM-dd" 格式
     */
    public static String ymd() {
        return LocalDate.now().format(DateTimeFormatter.ofPattern(DateUtil.YMD));
    }

    /**
     * @param date LocalDate对象
     * @return 日期 date 的 "yyyy-MM-dd" 格式
     */
    public static String ymd(Date date) {
        return localDateTime(date).format(DateTimeFormatter.ofPattern(YMD));
    }

    /**
     * @param date LocalDate对象
     * @return 日期 date 的 "yyyy-MM-dd" 格式
     */
    public static String ymd(LocalDate date) {
        return date.format(DateTimeFormatter.ofPattern(YMD));
    }

    /**
     * @param dateTime LocalDateTime对象
     * @return 日期 dateTime 的 "yyyy-MM-dd" 格式
     */
    public static String ymd(LocalDateTime dateTime) {
        return dateTime.format(DateTimeFormatter.ofPattern(YMD));
    }

    /**
     * 毫秒 的 "yyyy-MM-dd" 格式
     *
     * @param millisecond 1970/1/1 00:00:00 以来的毫秒数
     * @return 时间戳 millisecond 的 "yyyy-MM-dd" 格式
     */
    public static String ymd(long millisecond) {
        return localDate(millisecond).format(DateTimeFormatter.ofPattern(YMD));
    }

    /**
     * @return 当前日期的 "yyyy-MM-dd HH:mm:ss" 格式
     */
    public static String ymdHms() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(DateUtil.YMD_HMS));
    }

    /**
     * @param date Date对象
     * @return 对象 date 的 "yyyy-MM-dd HH:mm:ss" 格式
     */
    public static String ymdHms(Date date) {
        return localDateTime(date).format(DateTimeFormatter.ofPattern(YMD_HMS));
    }

    /**
     * @param date LocalDate对象
     * @return 对象 date 的 "yyyy-MM-dd HH:mm:ss" 格式
     */
    public static String ymdHms(LocalDate date) {
        return date.atStartOfDay().format(DateTimeFormatter.ofPattern(YMD_HMS));
    }

    /**
     * @param dateTime LocalDateTime对象
     * @return 对象 dateTime 的 "yyyy-MM-dd HH:mm:ss" 格式
     */
    public static String ymdHms(LocalDateTime dateTime) {
        return dateTime.format(DateTimeFormatter.ofPattern(YMD_HMS));
    }

    /**
     * 毫秒 的 "yyyy-MM-dd HH:mm:ss" 格式
     *
     * @param millisecond 1970/1/1 00:00:00 以来的毫秒数
     * @return 时间戳 millisecond 的 "yyyy-MM-dd HH:mm:ss" 格式
     */
    public static String ymdHms(long millisecond) {
        return localDateTime(millisecond).format(DateTimeFormatter.ofPattern(YMD_HMS));
    }

    /**
     * 20190101
     * @return 当前时间的 yyyyMMdd 格式
     */
    public static String yyyyMMdd() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(yyyyMMdd));
    }

    /**
     * Date 的 "yyyyMMdd" 格式， 例如：20200101
     *
     * @param date Date对象
     * @return 对象 date 的 "yyyyMMdd" 格式
     */
    public static String yyyyMMdd(Date date) {
        return localDateTime(date).format(DateTimeFormatter.ofPattern(yyyyMMdd));
    }

    /**
     * LocalDate 的 "yyyyMMdd" 格式， 例如：20200101
     *
     * @param date LocalDate对象
     * @return 对象 date 的 "yyyyMMdd" 格式
     */
    public static String yyyyMMdd(LocalDate date) {
        return date.format(DateTimeFormatter.ofPattern(yyyyMMdd));
    }

    /**
     * LocalDateTime 的 "yyyyMMdd" 格式，例如：20200101
     *
     * @param dateTime LocalDateTime对象
     * @return 对象 date 的 "yyyyMMdd" 格式
     */
    public static String yyyyMMdd(LocalDateTime dateTime) {
        return dateTime.format(DateTimeFormatter.ofPattern(yyyyMMdd));
    }

    /**
     * 毫秒 的 "yyyyMMdd" 格式
     *
     * @param millisecond 1970/1/1 00:00:00 以来的毫秒数
     * @return 时间戳 millisecond 的 "yyyyMMdd" 格式
     */
    public static String yyyyMMdd(long millisecond) {
        return localDate(millisecond).format(DateTimeFormatter.ofPattern(yyyyMMdd));
    }

    /**
     * 当前日期的指定格式
     * @param format 指定格式
     * @return 格式化后的字符串
     */
    public static String format(String format) {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(format));
    }

    /**
     *
     *
     * @param date Date
     * @param format String 日期格式
     * @return 格式化后的字符串
     */
    public static String format(Date date, String format) {
        return localDateTime(date).format(DateTimeFormatter.ofPattern(format));
    }

    /**
     * LocalDate -> 特定格式格式化日期字符串
     *
     * @param date   LocalDate
     * @param format 日期格式
     * @return 格式化后的字符串
     */
    public static String format(LocalDate date, String format) {
        return date.format(DateTimeFormatter.ofPattern(format));
    }

    /**
     * LocalDateTime -> 特定格式格式化字符串
     *
     * @param date   LocalDateTime
     * @param format 日期格式
     * @return 格式化后的字符串
     */
    public static String format(LocalDateTime date, String format) {
        return date.format(DateTimeFormatter.ofPattern(format));
    }

    /**
     * long 毫秒 -> 特定格式格式化日期字符串
     * @param timestamp 毫秒
     * @param format 格式
     * @return 格式化后的字符串
     */
    public static String format(long timestamp, String format) {
        return localDateTime(timestamp).format(DateTimeFormatter.ofPattern(format));
    }

    /**
     * 获得年的部分
     *
     * @param date 日期
     * @return 年的部分
     */
    public static int yearOf(Date date) {
        return localDateTime(date).getYear();
    }

    /**
     * 获得年的部分
     *
     * @param date LocalDate 日期
     * @return 年的部分
     */
    public static int yearOf(LocalDate date) {
        return date.getYear();
    }


    /**
     * 获得年的部分
     *
     * @param dateTime LocalDateTime 日期
     * @return 年的部分
     */
    public static int yearOf(LocalDateTime dateTime) {
        return dateTime.getYear();
    }


    /**
     * 获得年的部分
     * @param timestamp long 毫秒
     * @return 年数
     */
    public static int yearOf(long timestamp) {
        return localDateTime(timestamp).getYear();
    }

    /**
     * 获得月份，从1开始计数
     *
     * @param date 日期
     * @return 月份，从1开始计数
     */
    public static int monthOf(Date date) {
        return localDateTime(date).getMonthValue();
    }

    /**
     * 获得月份，从1开始计数
     *
     * @param date 日期
     * @return 月份，从1开始计数
     */
    public static int monthOf(LocalDate date) {
        return date.getMonthValue();
    }

    /**
     * 获得月份，从1开始计数
     *
     * @param dateTime 日期
     * @return 月份，从1开始计数
     */
    public static int monthOf(LocalDateTime dateTime) {
        return dateTime.getMonthValue();
    }

    /**
     * 获得月份，从1开始计数
     *
     * @param timestamp 毫秒
     * @return 月份，从1开始计数
     */
    public static int monthOf(long timestamp) {
        return localDateTime(timestamp).getMonthValue();
    }

    /**
     * 获得指定日期是这个日期所在月份的第几天<br>
     *
     * @param date Date 日期
     * @return 天
     */
    public static int dayOfMonth(Date date) {
        return localDateTime(date).getDayOfMonth();
    }

    /**
     * 获得指定日期是这个日期所在月份的第几天<br>
     *
     * @param date LocalDate 日期
     * @return 天
     */
    public static int dayOfMonth(LocalDate date) {
        return date.getDayOfMonth();
    }

    /**
     * 获得指定日期是这个日期所在月份的第几天<br>
     *
     * @param dateTime LocalDateTime 日期
     * @return 天
     */
    public static int dayOfMonth(LocalDateTime dateTime) {
        return dateTime.getDayOfMonth();
    }

    /**
     * 获得指定日期是这个日期所在月份的第几天<br>
     *
     * @param timestamp long 毫秒表示的时间戳
     * @return 天
     */
    public static int dayOfMonth(long timestamp) {
        return localDateTime(timestamp).getDayOfMonth();
    }

    /**
     * 获得指定日期是这个日期所在年的第几天
     *
     * @param date Date日期
     * @return 天
     */
    public static int dayOfYear(Date date) {
        return localDateTime(date).getDayOfYear();
    }

    /**
     * 获得指定日期是这个日期所在年的第几天
     *
     * @param date LocalDate 日期
     * @return 天
     */
    public static int dayOfYear(LocalDate date) {
        return date.getDayOfYear();
    }

    /**
     * 获得指定日期是这个日期所在年的第几天
     *
     * @param dateTime LocalDateTime 日期
     * @return 天
     */
    public static int dayOfYear(LocalDateTime dateTime) {
        return dateTime.getDayOfYear();
    }

    /**
     * 获得指定日期是这个日期所在年的第几天
     *
     * @param timestamp long 毫秒时间戳
     * @return 天
     */
    public static int dayOfYear(long timestamp) {
        return localDateTime(timestamp).getDayOfYear();
    }


    /**
     * 获得指定日期是星期几，1表示周一，7表示周日
     *
     * @param date 日期
     * @return 天
     */
    public static int dayOfWeek(Date date) {
        return localDateTime(date).getDayOfWeek().getValue();
    }

    /**
     * 获得指定日期是星期几，1表示周一，7表示周日
     *
     * @param date 日期
     * @return 天
     */
    public static int dayOfWeek(LocalDate date) {
        return date.getDayOfWeek().getValue();
    }

    /**
     * 获得指定日期是星期几，1表示周一，7表示周日
     *
     * @param dateTime 日期
     * @return 天
     */
    public static int dayOfWeek(LocalDateTime dateTime) {
        return dateTime.getDayOfWeek().getValue();
    }

    /**
     * 获得指定日期是星期几，1表示周一，7表示周日
     *
     * @param date long 毫秒表示的时间戳
     * @return 天
     */
    public static int dayOfWeek(long date) {
        return localDateTime(date).getDayOfWeek().getValue();
    }

    /**
     * 获得指定日期的小时数部分<br>24小时制
     *
     * @param date 日期
     * @return 小时数
     */
    public static int hourOf(Date date) {
        return localDateTime(date).getHour();
    }

    /**
     * 获得指定日期的小时数部分<br>24小时制
     *
     * @param date 日期
     * @return 小时数
     */
    public static int hourOf(LocalDate date) {
        return 0;
    }

    /**
     * 获得指定日期的小时数部分<br>24小时制
     *
     * @param dateTime 日期
     * @return 小时数
     */
    public static int hourOf(LocalDateTime dateTime) {
        return dateTime.getHour();
    }

    /**
     * 获得指定日期的小时数部分<br>24小时制
     *
     * @param timestamp long 毫秒格式的时间戳
     * @return 小时数
     */
    public static int hourOf(long timestamp) {
        return localDateTime(timestamp).getHour();
    }

    /**
     * 获得指定日期的分钟数部分<br>
     * 例如：10:04:15.250 =》 4
     *
     * @param date 日期
     * @return 分钟数
     */
    public static int minuteOf(Date date) {
        return localDateTime(date).getMinute();
    }

    /**
     * 获得指定日期的分钟数部分<br>
     * 例如：10:04:15.250 =》 4
     *
     * @param date 日期
     * @return 分钟数
     */
    public static int minuteOf(LocalDate date) {
        return 0;
    }

    /**
     * 获得指定日期的分钟数部分<br>
     * 例如：10:04:15.250 =》 4
     *
     * @param date 日期
     * @return 分钟数
     */
    public static int minuteOf(LocalDateTime date) {
        return date.getMinute();
    }

    /**
     * 获得指定日期的分钟数部分<br>
     * 例如：10:04:15.250 =》 4
     *
     * @param date long 毫秒格式的时间戳
     * @return 分钟数
     */
    public static int minuteOf(long date) {
        return localDateTime(date).getMinute();
    }

    /**
     * 获得指定日期的秒数部分<br>
     *
     * @param date 日期
     * @return 秒数
     */
    public static int secondOf(Date date) {
        return localDateTime(date).getSecond();
    }

    /**
     * 获得指定日期的秒数部分<br>
     *
     * @param date 日期
     * @return 秒数
     */
    public static int secondOf(LocalDate date) {
        return localDateTime(date).getSecond();
    }

    /**
     * 获得指定日期的秒数部分<br>
     *
     * @param date 日期
     * @return 秒数
     */
    public static int secondOf(LocalDateTime date) {
        return date.getSecond();
    }

    /**
     * 获得指定日期的秒数部分<br>
     *
     * @param date long 毫秒格式时间戳
     * @return 秒数
     */
    public static int secondOf(long date) {
        return localDateTime(date).getSecond();
    }

    /**
     * String格式时间戳 转 LocalDateTime
     *
     * @param dateStr 特定格式的日期
     * @param format  格式，例如yyyy-MM-dd
     * @return 日期对象
     */
    public static LocalDateTime parse(CharSequence dateStr, String format) {

        try {
            if (YMD_FORMAT_CACHE_LIST.contains(format)) {
                return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(format)).atStartOfDay();
            } else {
                return LocalDateTime.parse(dateStr, DateTimeFormatter.ofPattern(format));
            }
        } catch (DateTimeException e) {
            return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(format)).atStartOfDay();
        }
    }

    /**
     * yyy-MM-dd的日期字符串 转 LocalDateTime
     *
     * @param dateStr String yyyy-MM-dd的日期字符串
     * @return LocalDateTime
     */
    public static LocalDateTime parseYmd(CharSequence dateStr) {
        return parse(dateStr, YMD);
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"的日期字符串 转 LocalDateTime
     *
     * @param dateStr String "yyyy-MM-dd HH:mm:ss"格式的日期字符串
     * @return LocalDateTime
     */
    public static LocalDateTime parseYmdHms(CharSequence dateStr) {
        return parse(dateStr, YMD_HMS);
    }

    /**
     * Integer时间戳 转 LocalDateTime
     *
     * @param timestamp Integer格式的时间戳，如：20190101，20190101120111
     * @param format    格式，例如yyyyMMdd，yyyyMMddHHmmss
     * @return LocalDateTime
     */
    public static LocalDateTime parse(Integer timestamp, String format) {
        return parse(String.valueOf(timestamp), format);
    }

    /**
     * "yyy-MM-dd" 的 Integer时间戳 转 LocalDateTime
     *
     * @param timestamp String yyyy-MM-dd的日期字符串
     * @return LocalDateTime
     */
    public static LocalDateTime parseYmd(Integer timestamp) {
        return parse(timestamp, YMD);
    }

    /**
     * "yyyy-MM-dd HH:mm:ss" 的 Integer时间戳 转 LocalDateTime
     *
     * @param timestamp String "yyyy-MM-dd HH:mm:ss"格式的日期字符串
     * @return LocalDateTime
     */
    public static LocalDateTime parseYmdHms(Integer timestamp) {
        return parse(timestamp, YMD_HMS);
    }

    /**
     * String格式时间戳 转 long毫秒时间戳
     *
     * @param dateStr 特定格式的日期
     * @param format  格式，例如yyyy-MM-dd
     * @return long毫秒时间戳
     */
    public static long parse2Mills(CharSequence dateStr, String format) {
        return millis(parse(dateStr, format));
    }

    /**
     * yyy-MM-dd的日期字符串 转 long毫秒时间戳
     *
     * @param dateStr String yyyy-MM-dd的日期字符串
     * @return long毫秒时间戳
     */
    public static long parseYmd2Mills(CharSequence dateStr) {
        return millis(parse(dateStr, YMD));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"的日期字符串 转 long毫秒时间戳
     *
     * @param dateStr String "yyyy-MM-dd HH:mm:ss"格式的日期字符串
     * @return long毫秒时间戳
     */
    public static long parseYmdHms2Mills(CharSequence dateStr) {
        return millis(parse(dateStr, YMD_HMS));
    }

    /////////////////////////////////////////////////////////IDateCalc

    /**
     * 日期 +/- offset秒
     *
     * @param source 日期 Date对象
     * @param offset 偏移量 秒数
     * @return Date对象
     */
    public static Date offsetSeconds(Date source, int offset) {
        return date(localDateTime(source).plusSeconds(offset));
    }

    /**
     * 日期 +/- offset秒
     *
     * @param source 日期 LocalDate 对象
     * @param offset 偏移量 秒数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetSeconds(LocalDate source, int offset) {
        return localDateTime(source).plusSeconds(offset);
    }

    /**
     * 日期 +/- offset秒
     *
     * @param source 日期 LocalDateTime 对象
     * @param offset 偏移量 秒数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetSeconds(LocalDateTime source, int offset) {
        return source.plusSeconds(offset);
    }

    /**
     * 日期 +/- offset秒
     *
     * @param timestamp long 毫秒格式的时间戳
     * @param offset 偏移量 秒数
     * @return long 毫秒格式的时间戳
     */
    public static long offsetSeconds(long timestamp, int offset) {
        return millis(localDateTime(timestamp).plusSeconds(offset));
    }

    /**
     * 日期 +/- offset分钟
     *
     * @param source 日期 Date 对象
     * @param offset 偏移量 分钟数
     * @return Date 对象
     */
    public static Date offsetMinutes(Date source, int offset) {
        return date(localDateTime(source).plusMinutes(offset));
    }

    /**
     * 日期 +/- offset分钟
     *
     * @param source 日期 LocalDate 对象
     * @param offset 偏移量 分钟数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetMinutes(LocalDate source, int offset) {
        return localDateTime(source).plusMinutes(offset);
    }

    /**
     * 日期 +/- offset分钟
     *
     * @param source 日期 LocalDateTime 对象
     * @param offset 偏移量 分钟数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetMinutes(LocalDateTime source, int offset) {
        return source.plusMinutes(offset);
    }

    /**
     * 日期 +/- offset分钟
     *
     * @param timestamp long 毫秒格式的时间戳
     * @param offset 偏移量 分钟数
     * @return long 毫秒格式的时间戳
     */
    public static long offsetMinutes(long timestamp, int offset) {
        return millis(localDateTime(timestamp).plusMinutes(offset));
    }

    /**
     * 日期 +/- offset小时
     *
     * @param source 日期 Date对象
     * @param offset 偏移量 小时数
     * @return Date对象
     */
    public static Date offsetHours(Date source, int offset) {
        return date(localDateTime(source).plusHours(offset));
    }

    /**
     * 日期 +/- offset小时
     *
     * @param source 日期 LocalDate 对象
     * @param offset 偏移量 小时数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetHours(LocalDate source, int offset) {
        return localDateTime(source).plusHours(offset);
    }

    /**
     * 日期 +/- offset小时
     *
     * @param source 日期 LocalDateTime 对象
     * @param offset 偏移量 小时数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetHours(LocalDateTime source, int offset) {
        return source.plusHours(offset);
    }

    /**
     * 日期 +/- offset小时
     *
     * @param timestamp long 毫秒格式的时间戳
     * @param offset 偏移量 小时数
     * @return long 毫秒格式的时间戳
     */
    public static long offsetHours(long timestamp, int offset) {
        return millis(localDateTime(timestamp).plusHours(offset));
    }

    /**
     * 日期 +/- offset天
     *
     * @param source 日期 Date对象
     * @param offset 偏移量 天数
     * @return Date对象
     */
    public static Date offsetDays(Date source, int offset) {
        return date(localDateTime(source).plusDays(offset));
    }

    /**
     * 日期 +/- offset天
     *
     * @param source 日期 LocalDate 对象
     * @param offset 偏移量 天数
     * @return LocalDate 对象
     */
    public static LocalDate offsetDays(LocalDate source, int offset) {
        return source.plusDays(offset);
    }

    /**
     * 日期 +/- offset天
     *
     * @param source 日期 LocalDateTime 对象
     * @param offset 偏移量 天数
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetDays(LocalDateTime source, int offset) {
        return source.plusDays(offset);
    }

    /**
     * 日期 +/- offset天
     *
     * @param timestamp long 毫秒格式的时间戳
     * @param offset 偏移量 天数
     * @return long 毫秒格式的时间戳
     */
    public static long offsetDays(long timestamp, int offset) {
        return millis(localDateTime(timestamp).plusDays(offset));
    }


    /**
     * 日期 +/- offset月
     *
     * @param source 日期 Date对象
     * @param offset 偏移量  月的数量
     * @return Date对象
     */
    public static Date offsetMonths(Date source, int offset) {
        return date(localDateTime(source).plusMonths(offset));
    }

    /**
     * 日期 +/- offset月
     *
     * @param source 日期 Date对象
     * @param offset 偏移量  月的数量
     * @return Date对象
     */
    public static LocalDate offsetMonths(LocalDate source, int offset) {
        return source.plusMonths(offset);
    }

    /**
     * 日期 +/- offset月
     *
     * @param source 日期 Date对象
     * @param offset 偏移量  月的数量
     * @return Date对象
     */
    public static LocalDateTime offsetMonths(LocalDateTime source, int offset) {
        return source.plusMonths(offset);
    }

    /**
     * 日期 +/- offset月
     *
     * @param timestamp long 毫秒格式的时间戳
     * @param offset 偏移量  月的数量
     * @return long 毫秒格式的时间戳
     */
    public static long offsetMonths(long timestamp, int offset) {
        return millis(localDateTime(timestamp).plusMonths(offset));
    }

    /**
     * 日期 +/- offset年
     *
     * @param source 日期 Date对象
     * @param offset 偏移量  年的数量
     * @return Date对象
     */
    public static Date offsetYears(Date source, int offset) {
        return date(localDateTime(source).plusYears(offset));
    }

    /**
     * 日期 +/- offset年
     *
     * @param source 日期 LocalDate 对象
     * @param offset 偏移量  年的数量
     * @return LocalDate 对象
     */
    public static LocalDate offsetYears(LocalDate source, int offset) {
        return source.plusYears(offset);
    }

    /**
     * 日期 +/- offset年
     *
     * @param source 日期 LocalDateTime 对象
     * @param offset 偏移量  年的数量
     * @return LocalDateTime 对象
     */
    public static LocalDateTime offsetYears(LocalDateTime source, int offset) {
        return source.plusYears(offset);
    }

    /**
     * 日期 +/- offset年
     *
     * @param timestamp long 毫秒格式的时间戳
     * @param offset 偏移量  年的数量
     * @return long 毫秒格式的时间戳
     */
    public static long offsetYears(long timestamp, int offset) {
        return millis(localDateTime(timestamp).plusYears(offset));
    }

    /**
     * 获取某天的开始时间
     *
     * @param date 日期
     * @return Date对象
     */
    public static Date beginOfDay(Date date) {
        return date(localDateTime(date).toLocalDate());
    }

    /**
     * 获取某天的开始时间
     *
     * @param dateTime LocalDateTime 日期
     * @return LocalDateTime
     */
    public static LocalDateTime beginOfDay(LocalDateTime dateTime) {
        return dateTime.toLocalDate().atStartOfDay();
    }

    /**
     * 获取某天的开始时间
     *
     * @param timestamp long 毫秒形式的时间戳
     * @return long 毫秒形式的时间戳
     */
    public static long beginOfDay(long timestamp) {
        return millis(localDate(timestamp));
    }

    /**
     * 获取某天的结束时间
     *
     * @param date 日期
     * @return Date对象
     */
    public static Date endOfDay(Date date) {
        return date(localDate(date).plusDays(1).atStartOfDay().plus(-1, ChronoUnit.MILLIS));
    }

    /**
     * 获取某天的结束时间
     *
     * @param dateTime LocalDateTime
     * @return LocalDateTime
     */
    public static LocalDateTime endOfDay(LocalDateTime dateTime) {
        return localDate(dateTime).plusDays(1).atStartOfDay().plus(-1, ChronoUnit.MILLIS);
    }

    /**
     * 获取某天的结束时间
     *
     * @param timestamp long 毫秒形式的时间戳
     * @return long 毫秒形式的时间戳
     */
    public static long endOfDay(long timestamp) {
        return millis(localDate(timestamp).plusDays(1).atStartOfDay().plus(-1, ChronoUnit.MILLIS));
    }

    /**
     * 一周的起始日期
     *
     * @param dateTime
     * @return
     */
    public static LocalDateTime beginOfWeek(LocalDateTime dateTime) {
        return beginOfDay(dateTime.plusDays(-1 * (dateTime.getDayOfWeek().getValue() - 1)));
    }

    /**
     * 一周的起始日期
     *
     * @param timestamp
     * @return
     */
    public static LocalDateTime beginOfWeek(long timestamp) {
        return beginOfDay(localDateTime(timestamp).plusDays(-1 * localDate(timestamp).getDayOfWeek().getValue()));
    }

    /**
     * 一周的截止日期
     *
     * @param dateTime
     * @return
     */
    public static LocalDateTime endOfWeek(LocalDateTime dateTime) {
        return endOfDay(dateTime.plusDays(-1 * (dateTime.getDayOfWeek().getValue() - 1)).plusWeeks(1).plusDays(-1));
    }

    /**
     * 一周的截止日期
     *
     * @param timestamp
     * @return
     */
    public static LocalDateTime endOfWeek(long timestamp) {
        return endOfDay(localDateTime(timestamp).plusDays(-1 * localDateTime(timestamp).getDayOfWeek().getValue()).plusWeeks(1).plusDays(-1));
    }

    /**
     * 一月的起始日期
     *
     * @param dateTime
     * @return
     */
    public static LocalDateTime beginOfMonth(LocalDateTime dateTime) {
        return beginOfDay(dateTime.plusDays(-1 * dateTime.getDayOfMonth()).plusDays(1));
    }

    /**
     * 一月的起始日期
     *
     * @param  timestamp
     * @return
     */
    public static LocalDateTime beginOfMonth(long timestamp) {
        return beginOfDay(localDateTime(timestamp).plusDays(-1 * localDateTime(timestamp).getDayOfMonth()).plusDays(1));
    }

    /**
     * 一月的截止日期
     *
     * @param dateTime
     * @return
     */
    public static LocalDateTime endOfMonth(LocalDateTime dateTime) {
        return endOfDay(dateTime.plusMonths(1).plusDays(-1 * dateTime.getDayOfMonth()));
    }

    /**
     * 一月的截止日期
     *
     * @param timestamp
     * @return
     */
    public static LocalDateTime endOfMonth(long timestamp) {
        return endOfDay(localDateTime(timestamp).plusMonths(1).plusDays(-1 * localDateTime(timestamp).getDayOfMonth()));
    }

    /**
     * 一年的起始日期
     *
     * @param dateTime
     * @return
     */
    public static LocalDateTime beginOfYear(LocalDateTime dateTime) {
        return beginOfDay(dateTime.plusDays(-1 * dateTime.getDayOfYear()).plusDays(1));
    }

    /**
     * 一年的起始日期
     *
     * @param timestamp
     * @return
     */
    public static LocalDateTime beginOfYear(long timestamp) {
        return beginOfDay(localDateTime(timestamp).plusDays(-1 * localDateTime(timestamp).getDayOfYear()).plusDays(1));
    }

    /**
     * 一年的起始日期
     *
     * @param dateTime
     * @return
     */
    public static LocalDateTime endOfYear(LocalDateTime dateTime) {
        return endOfDay(dateTime.plusDays(-1 * dateTime.getDayOfYear()).plusYears(1));
    }

    /**
     * 一年的起始日期
     *
     * @param timestamp
     * @return
     */
    public static LocalDateTime endOfYear(long timestamp) {
        return endOfDay(localDateTime(timestamp).plusDays(-1 * localDateTime(timestamp).getDayOfYear()).plusYears(1));
    }

    /**
     * 判断两个日期相差的时长
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @param unit      相差的单位：相差 天{@link DateUnit#DAY}、小时{@link DateUnit#HOUR} 等
     * @param isAbs     日期间隔是否只保留绝对值正数
     * @return 日期差
     */
    public static long between(Date beginDate, Date endDate, DateUnit unit, boolean isAbs) {
        return new DateBetween(beginDate, endDate, isAbs).between(unit);
    }

    /**
     * 判断两个日期相差的天数<br>
     *
     * <pre>
     * 有时候我们计算相差天数的时候需要忽略时分秒。
     * 比如：2016-02-01 23:59:59和2016-02-02 00:00:00相差一秒
     * 如果isReset为{@code false}相差天数为0。
     * 如果isReset为{@code true}相差天数将被计算为1
     * </pre>
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @param isReset   是否重置时间为起始时间
     * @return 日期差
     */
    public static int daysBetween(Date beginDate, Date endDate, boolean isReset) {
        if (isReset) {
            beginDate = beginOfDay(beginDate);
            endDate = beginOfDay(endDate);
        }
        return (int) between(beginDate, endDate, DateUnit.DAY, false);
    }

    /**
     * 判断两个日期相差的天数，忽略时分秒
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差天数
     */
    public static int daysBetween(Date beginDate, Date endDate) {
        return daysBetween(beginDate, endDate, true);
    }

    /**
     * 判断两个日期相差的天数，忽略时分秒
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差天数
     */
    public static int daysBetween(LocalDate beginDate, LocalDate endDate) {
        return daysBetween(date(beginDate), date(endDate));
    }

    /**
     * 判断两个日期相差的天数，忽略时分秒
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差天数
     */
    public static int daysBetween(LocalDateTime beginDate, LocalDateTime endDate) {
        return daysBetween(date(beginDate), date(endDate));
    }

    /**
     * 判断两个日期相差的天数，忽略时分秒
     *
     * @param beginMills 起始日期（单位：毫秒）
     * @param endMills   结束日期（单位：毫秒）
     * @return 相差天数
     */
    public static int daysBetween(long beginMills, long endMills) {
        return daysBetween(date(beginMills), date(endMills));
    }

    /**
     * 计算指定指定时间区间内的周数
     *
     * @param beginDate 开始时间
     * @param endDate   结束时间
     * @param isReset   是否重置时间为起始时间
     * @return 周数
     */
    public static int weeksBetween(Date beginDate, Date endDate, boolean isReset) {
        if (isReset) {
            beginDate = beginOfDay(beginDate);
            endDate = beginOfDay(endDate);
        }
        return (int) between(beginDate, endDate, DateUnit.WEEK, false);
    }

    /**
     * 判断两个日期相差的周数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差周数
     */
    public static int weeksBetween(Date beginDate, Date endDate) {
        return weeksBetween(beginDate, endDate, true);
    }

    /**
     * 判断两个日期相差的周数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差周数
     */
    public static int weeksBetween(LocalDate beginDate, LocalDate endDate) {
        return weeksBetween(date(beginDate), date(endDate));
    }

    /**
     * 判断两个日期相差的周数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差周数
     */
    public static int weeksBetween(LocalDateTime beginDate, LocalDateTime endDate) {
        return weeksBetween(date(beginDate), date(endDate));
    }

    /**
     * 判断两个日期相差的周数
     *
     * @param beginMills 起始日期（单位：毫秒）
     * @param endMills   结束日期（单位：毫秒）
     * @return 相差周数
     */
    public static int weeksBetween(long beginMills, long endMills) {
        return weeksBetween(date(beginMills), date(endMills));
    }

    /**
     * 计算两个日期相差月数<br>
     * 在非重置情况下，如果起始日期的天大于结束日期的天，月数要少算1（不足1个月）
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @param isReset   是否重置时间为起始时间（重置天时分秒）
     * @return 相差月数
     */
    public static int monthsBetween(Date beginDate, Date endDate, boolean isReset) {
        return (int) (new DateBetween(beginDate, endDate).betweenMonth(isReset));
    }

    /**
     * 判断两个日期相差的月数，忽略天数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差月数
     */
    public static int monthsBetween(Date beginDate, Date endDate) {
        return monthsBetween(beginDate, endDate, true);
    }

    /**
     * 判断两个日期相差的月数，忽略天数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差月数
     */
    public static int monthsBetween(LocalDate beginDate, LocalDate endDate) {
        return monthsBetween(date(beginDate), date(endDate));
    }

    /**
     * 判断两个日期相差的月数，忽略天数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差月数
     */
    public static int monthsBetween(LocalDateTime beginDate, LocalDateTime endDate) {
        return monthsBetween(date(beginDate), date(endDate));
    }

    /**
     * 判断两个日期相差月数，忽略天数
     *
     * @param beginMills 起始日期（单位：毫秒）
     * @param endMills 结束日期（单位：毫秒）
     * @return 相差月数
     */
    public static int monthsBetween(long beginMills, long endMills) {
        return monthsBetween(localDate(beginMills), localDate(endMills));
    }

    /**
     * 计算两个日期相差年数<br>
     * 在非重置情况下，如果起始日期的月大于结束日期的月，年数要少算1（不足1年）
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @param isReset   是否重置时间为起始时间（重置月天时分秒）
     * @return 相差年数
     */
    public static int yearsBetween(Date beginDate, Date endDate, boolean isReset) {
        return (int) (new DateBetween(beginDate, endDate).betweenYear(isReset));
    }

    /**
     * 判断两个日期相差的年数，忽略月数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差年数
     */
    public static int yearsBetween(Date beginDate, Date endDate) {
        return yearsBetween(localDate(beginDate), localDate(endDate));
    }

    /**
     * 判断两个日期相差的年数，忽略月数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差年数
     */
    public static int yearsBetween(LocalDate beginDate, LocalDate endDate) {
        return endDate.getYear() - beginDate.getYear();
    }

    /**
     * 判断两个日期相差的年数，忽略月数
     *
     * @param beginDate 起始日期
     * @param endDate   结束日期
     * @return 相差年数
     */
    public static int yearsBetween(LocalDateTime beginDate, LocalDateTime endDate) {
        return endDate.getYear() - beginDate.getYear();
    }

    /**
     * 判断两个日期相差的年数，忽略月数
     *
     * @param beginMills 起始日期（单位：毫秒）
     * @param endMills  结束日期（单位：毫秒）
     * @return 相差年数
     */
    public static int yearsBetween(long beginMills, long endMills) {
        return localDate(endMills).getYear() - localDate(beginMills).getYear();
    }

    /////////////////////////////////////////////////////////IDateJudge

    /**
     * 判断时刻 date 是否在区间 [beginDate, endDate] 内
     *
     * @param date      时刻
     * @param beginDate 区间起点
     * @param endDate   区间终点
     * @return 判断时刻 date 是否在区间 [beginDate, endDate] 内
     */
    public static boolean isIn(Date date, Date beginDate, Date endDate) {
        long beginMills = beginDate.getTime();
        long endMills = endDate.getTime();
        long thisMills = date.getTime();

        return thisMills >= Math.min(beginMills, endMills) && thisMills <= Math.max(beginMills, endMills);
    }

    /**
     * 判断时刻 date 是否在区间 [beginDate, endDate] 内
     *
     * @param date      时刻
     * @param beginDate 区间起点
     * @param endDate   区间终点
     * @return 判断时刻 date 是否在区间 [beginDate, endDate] 内
     */
    public static boolean isIn(LocalDate date, LocalDate beginDate, LocalDate endDate) {
        long beginDay = beginDate.toEpochDay();
        long endDay = endDate.toEpochDay();
        long thisDay = date.toEpochDay();

        return thisDay >= Math.min(beginDay, endDay) && thisDay <= Math.max(beginDay, endDay);
    }

    /**
     * 判断时刻 date 是否在区间 [beginDate, endDate] 内
     *
     * @param dateTime      时刻
     * @param beginDateTime 区间起点
     * @param endDateTime   区间终点
     * @return 判断时刻 date 是否在区间 [beginDate, endDate] 内
     */
    public static boolean isIn(LocalDateTime dateTime, LocalDateTime beginDateTime, LocalDateTime endDateTime) {
        long beginSecs = beginDateTime.toEpochSecond(OffsetDateTime.now().getOffset());
        long endSecs = endDateTime.toEpochSecond(OffsetDateTime.now().getOffset());
        long thisSecs = dateTime.toEpochSecond(OffsetDateTime.now().getOffset());

        return thisSecs >= Math.min(beginSecs, endSecs) && thisSecs <= Math.max(beginSecs, endSecs);
    }

    /**
     * 此刻是上午?
     *
     * @return boolean
     */
    public static boolean isAM() {
        return localDateTime().getHour() < 12;
    }

    /**
     * 此刻是上午?
     *
     * @param dateTime LocalDateTime
     * @return boolean
     */
    public static boolean isAM(LocalDateTime dateTime) {
        return dateTime.getHour() < 12;
    }

    /**
     * 此刻是上午?
     *
     * @param date Date
     * @return boolean
     */
    public static boolean isAM(Date date) {
        return localDateTime(date).getHour() < 12;
    }

    /**
     * 此刻是上午?
     * @param timestamp long 毫秒
     * @return boolean
     */
    public static boolean isAM(long timestamp) {
        return localDateTime(timestamp).getHour() < 12;
    }

    /**
     * 此刻是下午?
     *
     * @return boolean
     */
    public static boolean isPM() {
        return localDateTime().getHour() >= 12;
    }

    /**
     * 此刻是下午?
     *
     * @param dateTime Date
     * @return boolean
     */
    public static boolean isPM(LocalDateTime dateTime) {
        return dateTime.getHour() >= 12;
    }

    /**
     * 此刻是下午?
     *
     * @param date Date
     * @return boolean
     */
    public static boolean isPM(Date date) {
        return localDateTime(date).getHour() >= 12;
    }

    /**
     * 此刻是下午?
     * @param timestamp long 毫秒
     * @return boolean
     */
    public static boolean isPM(long timestamp) {
        return localDateTime(timestamp).getHour() >= 12;
    }

}
